// ����:
// ������� ������������. ����������� �������. ����������� ������.
// ������� ����.

#include "General.h"

#include <iostream>
#include <tchar.h>
#define	  stop __asm nop

int _tmain(int argc, _TCHAR* argv[])
{
	//������� 1.������ �������� ������.
	{
	//�������� � ������������������ ������ ar �� �������� ���� MyString. 
	//�������� ������ const int N=5; , �� ������� ������ ���������������.
	
		//const int N=3;
		const int N = 5;
		MyString str1[N] = { MyString("First"), MyString("Second"), MyString("Third")};
  
	//�������� - ������ �����-������ ������
		for (int i = 0; i < N; i++)
		{
			std::cout << str1[i].GetString() << std::endl;
		}			
	}
	stop


	//������� 2.������ ���������� �� ������� ������.
	{
	//�������� � ������������������ ������ arPtr �� N
	//���������� �� ������� ���� MyString (���� ������� ��������� �����������!).
	//�������� ������ const int N=5; , �� ������� ������ ���������������.
	 
	//const int N=3;
	const int N = 5;
	MyString* arPtr[N] = { new MyString("First ptr"), new MyString("Second ptr"), new MyString("Third ptr") };
	//������ �����-������ ������
	for (int i = 0; i < N; i++)
	{
		if(arPtr[i])
		{
			std::cout << (*arPtr[i]).GetString() << std::endl;
		}else{ std::cout << "nullptr - Empty string" << std::endl; }			
	}
	}
		stop


		//������� 3.������� ������������.��������� ������������,
		// ������������ � ������� �����.

		//�������� �������� �������:
		//������� ����� Shape (������� ��������� ����� ������)
		//� ��� ����������� ������ Rect � Circle.
		//���������: ����� ������ � ������ ����� ������ � �������
		//� ����������� ������ (��������, ����� ������ ����� �������
		//������� => � ������� ������ ����� ������ ����������, �������
		//����� ���������� ���� ������.
		//���������: ��� �������� ����� �������� ������������ (RED,GREEN,BLUE...);



		//� ������������� ����������� ������� ������������� ��������
		//���������-����� ������������ �������� ������.
		//��� �������� � ����������� ������� ������������ ���� ����������
		//������������������ ������� ������������� � ������������ ��������
		//� ������������ �������

	Shape Shape1;
	Shape Shape2(RED);

	Rect Rect1;
	Rect Rect2(1);
	Rect Rect3(1,2,3,4);
	Rect Rect4(1, 2, 3, 4, GREEN);

	Circle Circle1;
	Circle Circle2(5);
	Circle Circle3(5, 3, 1, BLUE);
	stop
//////////////////////////////////////////////////////////////////////

	//������� 4.����������� �������.
	//4�) ������������� ������ Shape,Rect � Circle:
	//�������� � ������ ����� public ����� void WhereAmI().
	//���������� ������ ������� ������ �������� ��������� 
	//���������� ���� "Now I am in class Shape(Rect ��� Circle)".
	//��������� ����������� ��������, ��������� ���������.


	{
		Shape s(RED);
		Rect r(1, 2, 3, 4, GREEN);
		Circle c(5, 3, 1, BLUE);

	
		//����� ������ ������ ���������� � ��������� ��������???
		s.WhereAmI();	//	Shape (����� ����������� �� ����� ����������, ��� ��� �������� ������ ������)
		r.WhereAmI();	//	Rect
		c.WhereAmI();	//	Circle
		stop


		Shape* pShape = &s;
		Shape* pRect = &r;
		Shape* pCircle = &c;
    	pShape->WhereAmI();	//	Shape (������ ����������, �.�. ��������� �������� ����, �� ���� ������� ����� ������ ����� �������� ������)
		pRect->WhereAmI();	//	Shape (�� ����� �������� ������ ���� ������)
		pCircle->WhereAmI(); //	Shape
		stop


		//��������� ... �������� ������������
		Shape& rShape = s; //��������� s (��� ���������� Shape&)
		Shape& rRect = r; //��������� r
		Shape& rCircle = c; //��������� c
		rShape.WhereAmI();	//����� ����������� rShape	Shape
		rRect.WhereAmI();	//����� �����������	rRect	Shape
		rCircle.WhereAmI(); //����� ����������� rCircle	Shape
		stop
	}

	//4�) �������� � ������� � ����������� ������ �����������
	// ����� WhereAmIVirtual(). �� �������� � 4� ��������
	// ����������� ����� ����������� ��������, ���������� �
	// ������, ������������ � ���������� ���������.
	//��������� ����� ��������, ��������� �������.
	{
		Shape s(RED);
		Rect r(1, 2, 3, 4, GREEN);
		Circle c(5, 3, 1, BLUE);


		//����� ������ ������ ���������� � ��������� �������� (����� ����������� �� ����� ����������, ��� ��� �������� ������ ������)
		s.WhereAmIVirtual();	//	Shape
		r.WhereAmIVirtual();	//	Rect
		c.WhereAmIVirtual();	//	Circle
		stop


		Shape* pShape = &s;
		Shape* pRect = &r;
		Shape* pCircle = &c;
		pShape->WhereAmIVirtual();	//	Shape (��������, ����������� ������� ����������� �������) 
		pRect->WhereAmIVirtual();	//	Rect
		pCircle->WhereAmIVirtual();//	Circle
		stop


		//��������� ... �������� ������������
		Shape& rShape = s; //��������� s
		Shape& rRect = r; //��������� r
		Shape& rCircle = c; //��������� c
		rShape.WhereAmIVirtual();	//����� ����������� rShape	Shape (��������, ����������� ������� ����������� �������) 
		rRect.WhereAmIVirtual();	//����� �����������	rRect	Rect
		rCircle.WhereAmIVirtual(); //����� ����������� rCircle	Circle
		stop
	}


//////////////////////////////////////////////////////////////////////

	//������� 5.����������� �����������.
	//������������� ������:
	//a) ������� ���������������
	// ����������� (��� ��������� ����� virtual).
	//���������� ������� �����������
	//������ �������� ��������� ���������� ����
	// "Now I am in Shape's destructor!" ���
	// "Now I am in Rect's destructor!"
	//��������� ��������. ��������� ���������.

	// b) �������� � ���������� ������������ �������� ����� virtual 
	//��������� ��������.��������� �������.

	
	//���������: ����� ������������ ���������� � ��������� ������?
		//���� � ������������� ������� �����-�� �������������
		//�� ������� - ����������
		//���� �� ��������, ��� � ����������� ��������� ����-��
		//�� ������� - ��������

		Rect r(1,2,3,4);
		Shape* ar[]={new Shape(r), new Rect(r), new Circle(r), new Circle()};
		//�������� ��� ������� �������� ������� ����� WhereAmIVirtual()
	
		for (int i = 0; i < (sizeof(ar) / sizeof(ar[0])); i++)
		{
			ar[i]->WhereAmIVirtual();
			delete ar[i];
		}

	stop



	//������� 6*. � ��� ����������� ������� 1) � 2)
	{
		Shape* pShapes = new Rect[10];//1)  ���������� ������������ ������ ���������� ���� Shape �� ������� ���� Rect
		Rect* pRects = new Rect[10];//2) ���������� ������������ ������ ���������� ���� Rect �� ������� ���� Rect

		//���������� ������� ����� WhereAmIVirtual() ��� ������� �������� ����� �������� -
		//� ��� ����������� ��������???
		for (int i = 0; i < 10; i++)
		{
			pRects[i].WhereAmIVirtual();
		}
		/*
		for (int i = 0; i < 10; i++)
		{
			pShapes[i].WhereAmIVirtual();	//�������� �� ������ ��������, ��������� �������� ������, �����???
		}
		*/
		
		//���������� ����������� ����������� ������
		
			delete []pShapes; //�������� �����, ����� ���� ������
			delete[]pRects;
		
	}

//////////////////////////////////////////////////////////////////////

	//������� 7.����������� ������� � �������� ���������� ������� ���������. 

	{
		Rect r(1,2,3,4);
		Shape* p = &r;	
		p->WhereAmIVirtual();//Rect
		stop
	
		
		//4a �������� ���������� ������� ���������.
		//����������� ������� r � ��������� p �������� ����������� �������
		//WhereAmIVirtual()������ Shape
		p->Shape::WhereAmIVirtual();//Shape
		stop
	}


//////////////////////////////////////////////////////////////////////

	//������� 8.����� ����������� �������. 
	//������� � ������� ����� ����� void Inflate(int); ���������:
	//����� �� ����������� ����� ����� ��� �������� ������? => ��� ��� ����� ��������.
	//���������� ���� ����� ��� ����������� �������.
	{
		Rect r(1,2,3,4);
		Shape* p = &r;
		p->Inflate(5);
		Circle c(1,2.3);
		p = &c;
		p->Inflate(5);
	}


//////////////////////////////////////////////////////////////////////
	//������� 9. �������� ���������� �������, ������� ����� ��������� �����
	//���������� ���������� �� ������, � ���������� ������ MyString,
	//� ������� ������ ����� ������������� ����������

	MyString res = concatenation("hello","i'm","Svetlana",nullptr);
	stop

////////////////////////////////////////////////////////////////////////
/*
	//������� 10.����������� (union) C++. ������� ����.
	//1.
	//�������� ��������� ������ ��� ��������� ������������� �������� �����:
	//Bin - ��� ��������� �������������
	//Hex - ��� ����������������� �������������
	//Oct - ��� ������������� �������������.
	//��������� 1: - ��� �������� ����������� ������� ����.
	//��������� 2: - ������������� � ����� ��������������� ������� ���� �� ������,
	//��� ��� ��� ��� ����� ������� ����������� (union).
	//2.
	//� ������ ������ ������� ����� Show, ������� ������ �������� �������� �
	//��������������� ����
	//3.
	//����������� ����������� MyByte ������������ ������������ ����������� ��������������
	//����� � ��� �� ��������� ��-�������:
	//�) ��������: ����������, �����������������, ������������, �������� �������� ����� 
	//          � ����� ������, ��������������� ��������� �������� (���� ���� ������������);
	//�) �������� ��������� (��������� ����������� ���������) �����������������,
	//			������������, �������� �����;
	//�) �������� ��������� ��������, ������������ ��� ����������������� �����;

	MyByte byte(0x1f);
	byte.ShowHex();
	byte.ShowBin();
	//...


*/
	return 0;
}//endmain

